/**
 * 用户相关API服务
 * 基于uniapp的request封装
 */

// API配置常量
// 新增：从userq.js中导入的API
import upload from '@/utils/upload'
import request from '@/utils/request'

// 在API_CONFIG中添加userq.js中的API端点
const API_CONFIG = {
  // 用户相关
  userInfo: '/system/user/get',
  userUpdate: '/system/user/update',
  userConfig: '/system/user-config/get',
  userConfigUpdate: '/system/user-config/update',
  
  // 系统字典
  dictData: '/app-api/system/dict-data/type',
  
  // 基础数据
  processList: '/md/process/list',
  prodCenterList: '/md/prod-center/list',
  warehousePage: '/md/warehouse/page',
  
  // 密码修改
  changePassword: '/system/user/change-password',
  
  // 新增：个人中心相关API
  updateUserPwd: '/system/user/profile/update-password',
  getUserProfile: '/system/user/profile/get',
  updateUserProfile: '/system/user/profile/update',
  uploadAvatar: '/system/user/profile/update-avatar',
  getUserList: '/system/user/page'
}

// 新增：个人中心相关函数（从userq.js迁移）

// 用户密码重置
export function updateUserPwd(oldPassword, newPassword) {
  const data = {
    oldPassword,
    newPassword
  }
  return request({
    url: API_CONFIG.updateUserPwd,
    method: 'put',
    data: data
  })
}

// 查询用户个人信息（包含工作信息）- 已移除，使用缓存数据
// export function getUserProfile() {
//   return request({
//     url: API_CONFIG.getUserProfile,
//     method: 'get'
//   })
// }

// 修改用户个人信息（包含工作信息）- 已移除，使用缓存数据
// export function updateUserProfile(data) {
//   return request({
//     url: API_CONFIG.updateUserProfile,
//     method: 'put',
//     data: data
//   })
// }

// 用户头像上传
export function uploadAvatar(data) {
  return upload({
    url: API_CONFIG.uploadAvatar,
    name: 'avatarFile',
    file: data.filePath
  })
}

// 获取用户完整信息（包含关联表数据）- 已移除，使用缓存数据
// export function getUserFullProfile() {
//   return request({
//     url: API_CONFIG.getUserFullProfile,
//     method: 'get'
//   })
// }

// 获取用户列表（分页）
export function getUserList(params) {
  return request({
    url: API_CONFIG.getUserList,
    method: 'get',
    params: {
      pageNo: 1,
      pageSize: 100,
      ...params
    }
  })
}

// 在UserService类中添加新方法
class UserService {
  /**
   * 获取用户详细信息
   * @param {number} userId - 用户ID
   * @returns {Promise<Object>} 用户信息
   */
  static async getUserInfo(userId) {
    return request({
      url: API_CONFIG.userInfo,
      method: 'GET',
      data: { id: userId }
    })
  }

  /**
   * 获取用户配置信息
   * @param {number} userId - 用户ID
   * @returns {Promise<Object>} 用户配置信息
   */
  static async getUserConfig(userId) {
    return request({
      url: API_CONFIG.userConfig,
      method: 'GET',
      data: { id: userId }
    })
  }

  /**
   * 更新用户基本信息
   * @param {Object} data - 更新数据
   * @returns {Promise<Object>} 更新结果
   */
  static async updateUserInfo(data) {
    return request({
      url: API_CONFIG.userUpdate,
      method: 'PUT',
      data
    })
  }

  /**
   * 更新用户配置信息
   * @param {Object} data - 配置数据
   * @returns {Promise<Object>} 更新结果
   */
  static async updateUserConfig(data) {
    return request({
      url: API_CONFIG.userConfigUpdate,
      method: 'PUT',
      data
    })
  }

  /**
   * 获取用户完整信息
   * @param {number} userId - 用户ID
   * @returns {Promise<Object>} 完整用户信息
   */
  static async getUserDetail(userId) {
    try {
      const [userInfo, userConfig] = await Promise.all([
        this.getUserInfo(userId),
        this.getUserConfig(userId)
      ])
      
      return {
        userInfo,
        userConfig
      }
    } catch (error) {
      console.error('获取用户详情失败:', error)
      throw error
    }
  }

  /**
   * 修改密码
   * @param {Object} data - 密码数据
   * @param {string} data.oldPassword - 原密码
   * @param {string} data.newPassword - 新密码
   * @returns {Promise<Object>} 修改结果
   */
  static async changePassword(data) {
    return request({
      url: API_CONFIG.changePassword,
      method: 'POST',
      data
    })
  }

  /**
   * 获取用户资料
   * @returns {Promise<Object>} 用户资料
   */
  static async getUserProfile() {
    return this.getUserInfo()
  }

  /**
   * 更新用户资料
   * @param {Object} data - 用户资料数据
   * @returns {Promise<Object>} 更新结果
   */
  static async updateUserProfile(data) {
    return this.updateUserInfo(data)
  }

  /**
   * 更新用户密码
   * @param {Object} data - 密码数据
   * @param {string} data.oldPassword - 原密码
   * @param {string} data.newPassword - 新密码
   * @returns {Promise<Object>} 更新结果
   */
  static async updateUserPwd(data) {
    return this.changePassword(data)
  }


  /**
   * 更新用户个人信息
   * @param {Object} data - 更新数据
   * @returns {Promise<Object>} 更新结果
   */
  static async updateUserPersonalInfo(data) {
    return updateUserProfile(data)
  }

  /**
   * 修改用户密码
   * @param {string} oldPassword - 原密码
   * @param {string} newPassword - 新密码
   * @returns {Promise<Object>} 修改结果
   */
  static async changeUserPassword(oldPassword, newPassword) {
    return updateUserPwd(oldPassword, newPassword)
  }

  /**
   * 上传用户头像
   * @param {Object} fileData - 文件数据
   * @returns {Promise<Object>} 上传结果
   */
  static async uploadUserAvatar(fileData) {
    return uploadAvatar(fileData)
  }
}

// 系统服务类
class SystemService {
  /**
   * 获取数据字典
   * @param {string} type - 字典类型
   * @returns {Promise<Array>} 字典数据
   */
  static async getDictData(type) {
    return request({
      url: API_CONFIG.dictData,
      method: 'GET',
      data: { type }
    })
  }

  /**
   * 获取班次列表
   * @returns {Promise<Array>} 班次数据
   */
  static async getShiftList() {
    return this.getDictData('班次')
  }

  /**
   * 获取班别列表
   * @returns {Promise<Array>} 班别数据
   */
  static async getClassList() {
    return this.getDictData('班别')
  }

  /**
   * 获取工序列表
   * @param {Object} params - 查询参数
   * @returns {Promise<Array>} 工序数据
   */
  static async getProcessList(params = {}) {
    return request({
      url: API_CONFIG.processList,
      method: 'GET',
      data: params
    })
  }

  /**
   * 获取加工中心列表
   * @param {Object} params - 查询参数
   * @param {string} params.processNo - 工序编码（可选）
   * @param {string} params.prodCenterNo - 加工中心编码（可选）
   * @param {string} params.prodCenter - 加工中心名称（可选）
   * @returns {Promise<Array>} 加工中心数据
   */
  static async getProdCenterList(params = {}) {
    try {
      const res = await request({
        url: API_CONFIG.prodCenterList,
        method: 'GET',
        params
      })
      return res.code === 0 ? res.data : []
    } catch (error) {
      console.error('获取加工中心列表失败:', error)
      return []
    }
  }

  /**
   * 获取加工中心选项（下拉框格式）
   * @param {string} processNo - 工序编码（可选）
   * @returns {Promise<Array>} 加工中心选项数组
   */
  static async getProdCenterOptions(processNo) {
    const params = {}
    if (processNo) {
      params.processNo = processNo
    }
    
    const list = await this.getProdCenterList(params)
    return list.map(item => ({
      value: item.prodCenterNo,
      text: item.prodCenter,
      ...item
    }))
  }

  /**
   * 获取仓库列表
   * @param {number} pageNo - 页码
   * @param {number} pageSize - 每页条数
   * @param {Object} params - 其他参数
   * @returns {Promise<Object>} 仓库分页数据
   */
  static async getWarehouseList(pageNo = 1, pageSize = 100, params = {}) {
    return request({
      url: API_CONFIG.warehousePage,
      method: 'GET',
      data: {
        pageNo,
        pageSize,
        ...params
      }
    })
  }

  /**
   * 获取所有仓库（不分页）
   * @returns {Promise<Array>} 仓库列表
   */
  static async getAllWarehouses() {
    const result = await this.getWarehouseList(1, 1000)
    return result.records || []
  }
}

// 缓存管理
class CacheManager {
  /**
   * 设置用户信息缓存
   * @param {Object} userInfo - 用户信息
   * @param {number} expire - 过期时间（毫秒）
   */
  static setUserInfo(userInfo, expire = 2 * 24 * 60 * 60 * 1000) { // 默认2天
    const data = {
      value: userInfo,
      timestamp: Date.now(),
      expire
    }
    uni.setStorageSync('userInfo', data)
  }

  /**
   * 获取用户信息缓存
   * @returns {Object|null} 用户信息
   */
  static getUserInfo() {
    const data = uni.getStorageSync('userInfo')
    if (!data) return null
    
    if (Date.now() - data.timestamp > data.expire) {
      uni.removeStorageSync('userInfo')
      return null
    }
    
    return data.value
  }

  /**
   * 设置用户配置缓存
   * @param {Object} userConfig - 用户配置
   * @param {number} expire - 过期时间（毫秒）
   */
  static setUserConfig(userConfig, expire = 2 * 24 * 60 * 60 * 1000) { // 默认2天
    const data = {
      value: userConfig,
      timestamp: Date.now(),
      expire
    }
    uni.setStorageSync('userConfig', data)
  }

  /**
   * 获取用户配置缓存
   * @returns {Object|null} 用户配置
   */
  static getUserConfig() {
    const data = uni.getStorageSync('userConfig')
    if (!data) return null
    
    if (Date.now() - data.timestamp > data.expire) {
      uni.removeStorageSync('userConfig')
      return null
    }
    
    return data.value
  }

  /**
   * 清除所有缓存
   */
  static clearAll() {
    uni.clearStorageSync()
  }

  /**
   * 清除用户相关缓存
   */
  static clearUserCache() {
    uni.removeStorageSync('userInfo')
    uni.removeStorageSync('userConfig')
  }
}

// 工具函数
class Utils {
  /**
   * 验证手机号
   * @param {string} mobile - 手机号
   * @returns {boolean} 是否有效
   */
  static validateMobile(mobile) {
    return /^1[3-9]\d{9}$/.test(mobile)
  }

  /**
   * 验证邮箱
   * @param {string} email - 邮箱
   * @returns {boolean} 是否有效
   */
  static validateEmail(email) {
    return /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/.test(email)
  }

  /**
   * 验证密码强度
   * @param {string} password - 密码
   * @returns {Object} 强度信息
   */
  static checkPasswordStrength(password) {
    let strength = 0
    
    if (password.length >= 8) strength += 1
    if (/[a-z]/.test(password)) strength += 1
    if (/[A-Z]/.test(password)) strength += 1
    if (/[0-9]/.test(password)) strength += 1
    if (/[^a-zA-Z0-9]/.test(password)) strength += 1
    
    const levels = ['弱', '中', '强']
    return {
      level: levels[Math.min(strength - 1, 2)],
      score: strength,
      color: strength <= 2 ? '#ff4d4f' : strength === 3 ? '#faad14' : '#52c41a'
    }
  }
}

// 导出服务
export {
  UserService,
  SystemService,
  CacheManager,
  Utils
}

// 默认导出
export default {
  UserService,
  SystemService,
  CacheManager,
  Utils
}